package com.sheng.leetcode.year2023.month05.day25;

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;

/**
 * @author liusheng
 * @date 2023/05/25
 * <p>
 * 2451. 差值数组不同的字符串<p>
 * <p>
 * 给你一个字符串数组 words ，每一个字符串长度都相同，令所有字符串的长度都为 n 。<p>
 * 每个字符串 words[i] 可以被转化为一个长度为 n - 1 的 差值整数数组 difference[i] ，<p>
 * 其中对于 0 <= j <= n - 2 有 difference[i][j] = words[i][j+1] - words[i][j] 。<p>
 * 注意两个字母的差值定义为它们在字母表中 位置 之差，也就是说 'a' 的位置是 0 ，'b' 的位置是 1 ，'z' 的位置是 25 。<p>
 * 比方说，字符串 "acb" 的差值整数数组是 [2 - 0, 1 - 2] = [2, -1] 。<p>
 * words 中所有字符串 除了一个字符串以外 ，其他字符串的差值整数数组都相同。你需要找到那个不同的字符串。<p>
 * 请你返回 words中 差值整数数组 不同的字符串。<p>
 * <p>
 * 示例 1：<p>
 * 输入：words = ["adc","wzy","abc"]<p>
 * 输出："abc"<p>
 * 解释：<p>
 * - "adc" 的差值整数数组是 [3 - 0, 2 - 3] = [3, -1] 。<p>
 * - "wzy" 的差值整数数组是 [25 - 22, 24 - 25]= [3, -1] 。<p>
 * - "abc" 的差值整数数组是 [1 - 0, 2 - 1] = [1, 1] 。<p>
 * 不同的数组是 [1, 1]，所以返回对应的字符串，"abc"。<p>
 * <p>
 * 示例 2：<p>
 * 输入：words = ["aaa","bob","ccc","ddd"]<p>
 * 输出："bob"<p>
 * 解释：除了 "bob" 的差值整数数组是 [13, -13] 以外，其他字符串的差值整数数组都是 [0, 0] 。<p>
 * <p>
 * 提示：<p>
 * 3 <= words.length <= 100<p>
 * n == words[i].length<p>
 * 2 <= n <= 20<p>
 * words[i] 只含有小写英文字母。<p>
 * <p>
 * 来源：力扣（LeetCode）<p>
 * 链接：<a href="https://leetcode.cn/problems/odd-string-difference">2451. 差值数组不同的字符串</a><p>
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。<p>
 */
public class LeetCode2451 {

    @Test
    public void test01() {
//        String[] words = {"adc", "wzy", "abc"};
//        String[] words = {"aaa", "bob", "ccc", "ddd"};
        String[] words = {"ddd", "poo", "baa", "onn"};
        System.out.println(new Solution().oddString(words));
    }
}

class Solution {
    public String oddString(String[] words) {
        int n = words[0].length();
        int index = 0;
        int[] diff = new int[n - 1];
        // 不同的字符串的位置
        int index1 = 0;
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            if (i == 0) {
                for (int j = 0; j < n - 1; j++) {
                    diff[j] = (words[i].charAt(j + 1) - 'a') - (words[i].charAt(j) - 'a');
                }
                map.put("0", 1);
            } else {
                boolean flag = true;
                for (int j = 0; j < n - 1; j++) {
                    if (diff[j] != (words[i].charAt(j + 1) - 'a') - (words[i].charAt(j) - 'a')) {
                        flag = false;
                        index1 = i;
                        break;
                    }
                }
                if (flag) {
                    map.put("0", map.getOrDefault("0", 0) + 1);
                } else {
                    map.put("1", map.getOrDefault("1", 0) + 1);
                }
                if (map.containsKey("0") && map.containsKey("1")) {
                    if (map.get("0") == 1 && map.get("1") > 1) {
                        return words[index];
                    } else if (map.get("0") > 1 && map.get("1") == 1) {
                        return words[index1];
                    }
                }
            }
        }
        return "";
    }
}
